\documentclass[a4paper,11pt]{article}

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[french]{babel}
\usepackage{lmodern}

\usepackage{graphicx}
\usepackage{float}

\usepackage[hyperfootnotes=false]{hyperref}
\usepackage[bottom]{footmisc}
\usepackage[top=4cm,bottom=4cm,left=3cm,right=3cm]{geometry}

\usepackage{tikz}

\definecolor{commentGreen}{RGB}{0,127,0}

\usepackage{listings}
%\usepackage[usenames,dvipsnames]{xcolor}
\lstset{
    language=C,
    numbers=left, 
    stepnumber=1, 
    frame=single,
    belowskip=2.5em,
    basicstyle=\footnotesize,
    backgroundcolor=\color{white},
    keywordstyle=\color{blue},
    commentstyle=\color{commentGreen},
    stringstyle=\color{red}, 
    numberstyle=\color{gray},
    morekeywords = {GList, thread\_t, ucontext\_t},
    captionpos=b,
}
\renewcommand\lstlistingname{Extrait de code}

\hypersetup{
    colorlinks=false,
    pdfborder={0 0 0},
}

\usepackage{array}
\newcolumntype{M}[1]{>{\raggedright}m{#1}}

\usepackage{appendix}

\newcommand{\degree}{\ensuremath{^\circ}}

\begin{document}

\renewcommand{\contentsname}{Sommaire}

\title{\begin{figure}[!h]\begin{center}\includegraphics[scale=0.08]{Logo_ENSEIRB-MATMECA.png}\end{center}\end{figure}\Huge{\textbf{Projet Système}}\\\Large{\textsc{\\Adresse svn :\\\href{http://code.google.com/p/projet-systeme-s8/}{http://code.google.com/p/projet-systeme-s8/}}}\\\bigskip{}Encadrant : François Tessier}
\author{\Large{Groupe :} \\ \\ \Large{Sarah Blondeau} \\ \Large{Alban De Martin} \\ \Large{Joffrey Diebold} \\ \Large{Matirina Mata} \\ \Large{Antoine Nadif} \\ \Large{Sven Taton}}
\date{\Large{Mai 2013}}

\maketitle

\newpage

\tableofcontents

\newpage

\section{Implémentation}

\subsection{Structures utilisées}

\begin{itemize}
    \item Nous utilisons une structure \texttt{thread\_info} contenant les informations sur chaque thread créé :
\begin{lstlisting}[caption=structure thread\_info]
typedef struct {
    int id_thread;   // identifiant du thread : 0 pour le main et
                     // incremente a chaque nouveau thread cree

    int state;       // etat du thread : DEAD (0), ACTIVE (1),
                     // To_Be_DESTROYED(2), NON_ACTIVE(3)

    int is_joined;   // booleen indiquant si la fin d'execution d'un
                     // thread est attendue par un autre thread (utilise
                     // pour thread_join)

    ucontext_t attr; // structure de contexte liee au thread

    void * result;   // valeur courante calculee par le thread
} thread_info;
\end{lstlisting}

    \item Afin de gérer les threads créés, nous utilisons --- depuis la bibliothèque \textbf{glib} --- la structure de gList et les fonctions qui lui sont associées.
\begin{lstlisting}[caption=déclaration d'une glist]
GList * active_threads;
\end{lstlisting}

Cette liste contient tous les threads qui sont créés par appel de \texttt{thread\_create}. Elle est nécessaire dans la gestion du passage de la main comme implémenté dans \texttt{thread\_yield}.
\end{itemize}

\subsection{Implémentation des fonctions}

\subsubsection{La fonction \texttt{thread\_self}}

La fonction \texttt{thread\_self} va renvoyer l’identifiant du thread courant. L’accès se fait grâce au pointeur sur la variable globale \texttt{running\_thread}. Il est ensuite converti en type \texttt{thread\_t}.

\subsubsection{La fonction \texttt{thread\_create}}

Cette fonction va permettre la création de nos threads, le premier thread créé sera le main.\\
\\
Changement par rapport à \texttt{pthread\_create}, elle est définie par :
\begin{lstlisting}[caption=prototype de la fonction pthread\_create]
extern int thread_create(thread_t * newthread,
                         ucontext_t * attr,
                         void * (*func)(void *),
                         void * funcarg);
\end{lstlisting}

La variable \texttt{newthread} est un pointeur sur le thread a créer. Nous avons rajouté la variable \texttt{attr} pour permettre de lui associer un contexte déjà créé. Ce contexte est initialisé en appelant la fonction \texttt{thread\_attr\_init} : qui permet de définir un contexte par défaut si l’argument \texttt{NULL} lui est passé, ou un contexte particulier que l’on passe en argument. Les arguments \texttt{void * (*func)(void*)} et \texttt{void * funcarg} représentent la fonction associée au thread ainsi que ses arguments à passer en paramètre.\\

Dans la fonction \texttt{thread\_create}, si aucun thread n'a encore été créé nous commençons par définir le main\_thread en le liant au contexte actuel. Ensuite on crée le thread passé en paramètre. Pour cela on utilise la variable \texttt{globale thread\_to\_create} de type \texttt{thread\_info} dont on initialise les paramètres. Si le \texttt{main\_thread} est le thread courant, on définit le thread a créer comme actif, sinon on le désactive. Après avoir initialisé le contexte du thread on le rajoute à notre gList de threads. Ensuite on convertit le \texttt{thread\_to\_create} en type \texttt{thread\_t} pour définir le nouveau thread.

\subsubsection{La fonction \texttt{thread\_yield}}

Cette fonction permet de passer la main à un autre thread. Concrètement, cela correspond à un déplacement du thread courant à la fin de la liste des threads actifs. Le nouveau thread courant sera le premier élément de cette liste.

\subsubsection{La fonction \texttt{thread\_join}}

Cette fonction permet au thread courant d'attendre la fin de l'exécution d’un autre thread. Elle retourne une valeur d’erreur (\texttt{EINVAL}) si le thread en paramètre est déjà attendu. Sinon, on passe la main à un autre thread jusqu'à ce que l’état du thread en paramètre soit \texttt{NON\_ACTIVE}. Ensuite on effectue un \texttt{swapcontext} entre le thread à attendre et le thread courant puis on récupère la valeur de retour du thread joint. Enfin si l’état du thread attendu est \texttt{TO\_BE\_DESTROYED}, on libère la ressource du thread joint.

\subsubsection{La fonction \texttt{thread\_exit}}

Cette fonction quitte le thread courant en renvoyant la valeur de retour \texttt{retval} afin qu’un thread ayant appelé la fonction \texttt{thread\_join} sur ce dernier puisse la récupérer.

\texttt{thread\_exit} permet donc d’enregistrer le champ result du thread courant dans \texttt{retval}. Elle commence à faire les libérations nécessaires à la suppression de ce thread et change son état pour \texttt{TO\_BE\_DESTROYED} avant de passer la main.  Le reste de la libération de la ressource s’effectue dans \texttt{thread\_join}.

\subsection{Tests}

\subsubsection{example.c}

Lors de la compilation du fichier example.c, nous arrivons à créer nos threads et à les joindre mais il ne semble pas que la terminaison soit assurée.

Nous ne savons pas où placer l'état du thread depuis ACTIF vers NON\_ACTIF et vice-versa.

Nous rencontrons un problème dans la conversion du type thread\_info en thread\_t.

\subsubsection{Test n\degree1 -- main.c}

\subsubsection{Test n\degree2 -- switch.c}

\subsubsection{Autres programmes}

\subsubsection{Solutions envisagées}

\end{document}
